home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / containers / Grid.as < prev    next >
Text File  |  2014-03-27  |  12KB  |  386 lines
  1. package mx.containers
  2. {
  3.    import mx.containers.gridClasses.GridColumnInfo;
  4.    import mx.containers.gridClasses.GridRowInfo;
  5.    import mx.core.EdgeMetrics;
  6.    import mx.core.mx_internal;
  7.    
  8.    use namespace mx_internal;
  9.    
  10.    public class Grid extends Box
  11.    {
  12.       
  13.       mx_internal static const VERSION:String = "3.0.0.0";
  14.        
  15.       
  16.       private var columnWidths:Array;
  17.       
  18.       private var rowHeights:Array;
  19.       
  20.       private var needToRemeasure:Boolean = true;
  21.       
  22.       public function Grid()
  23.       {
  24.          super();
  25.       }
  26.       
  27.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  28.       {
  29.          var _loc4_:int = 0;
  30.          var _loc5_:GridRow = null;
  31.          if(needToRemeasure)
  32.          {
  33.             measure();
  34.          }
  35.          super.updateDisplayList(param1,param2);
  36.          var _loc3_:int = 0;
  37.          var _loc6_:Array = [];
  38.          var _loc7_:int = 0;
  39.          while(_loc7_ < numChildren)
  40.          {
  41.             if((_loc5_ = GridRow(getChildAt(_loc7_))).includeInLayout)
  42.             {
  43.                _loc6_.push(_loc5_);
  44.                _loc3_++;
  45.             }
  46.             _loc7_++;
  47.          }
  48.          _loc4_ = 0;
  49.          while(_loc4_ < _loc3_)
  50.          {
  51.             _loc5_ = _loc6_[_loc4_];
  52.             rowHeights[_loc4_].y = _loc5_.y;
  53.             rowHeights[_loc4_].height = _loc5_.height;
  54.             _loc4_++;
  55.          }
  56.          _loc4_ = 0;
  57.          while(_loc4_ < _loc3_)
  58.          {
  59.             _loc5_ = _loc6_[_loc4_];
  60.             _loc5_.doRowLayout(_loc5_.width * _loc5_.scaleX,_loc5_.height * _loc5_.scaleY);
  61.             _loc4_++;
  62.          }
  63.       }
  64.       
  65.       private function distributeItemWidth(param1:GridItem, param2:int, param3:Number, param4:Array) : void
  66.       {
  67.          var _loc12_:int = 0;
  68.          var _loc13_:GridColumnInfo = null;
  69.          var _loc14_:Number = NaN;
  70.          var _loc15_:Number = NaN;
  71.          var _loc5_:Number = param1.maxWidth;
  72.          var _loc6_:Number = param1.getExplicitOrMeasuredWidth();
  73.          var _loc7_:Number = param1.minWidth;
  74.          var _loc8_:int = param1.colSpan;
  75.          var _loc9_:Number = param1.percentWidth;
  76.          var _loc10_:Number = 0;
  77.          var _loc11_:Boolean = false;
  78.          _loc12_ = param2;
  79.          while(_loc12_ < param2 + _loc8_)
  80.          {
  81.             _loc13_ = param4[_loc12_];
  82.             _loc6_ -= _loc13_.preferred;
  83.             _loc7_ -= _loc13_.min;
  84.             _loc10_ += _loc13_.flex;
  85.             _loc12_++;
  86.          }
  87.          if(_loc8_ > 1)
  88.          {
  89.             _loc14_ = param3 * (_loc8_ - 1);
  90.             _loc6_ -= _loc14_;
  91.             _loc7_ -= _loc14_;
  92.          }
  93.          if(_loc10_ == 0)
  94.          {
  95.             _loc10_ = _loc8_;
  96.             _loc11_ = true;
  97.          }
  98.          _loc6_ = _loc6_ > 0 ? Number(Math.ceil(_loc6_ / _loc10_)) : Number(0);
  99.          _loc7_ = _loc7_ > 0 ? Number(Math.ceil(_loc7_ / _loc10_)) : Number(0);
  100.          _loc12_ = param2;
  101.          while(_loc12_ < param2 + _loc8_)
  102.          {
  103.             _loc13_ = param4[_loc12_];
  104.             _loc15_ = !!_loc11_ ? Number(1) : Number(_loc13_.flex);
  105.             _loc13_.preferred += _loc6_ * _loc15_;
  106.             _loc13_.min += _loc7_ * _loc15_;
  107.             if(_loc9_)
  108.             {
  109.                _loc13_.percent = Math.max(_loc13_.percent,_loc9_ / _loc8_);
  110.             }
  111.             _loc12_++;
  112.          }
  113.          if(_loc8_ == 1 && _loc5_ < _loc13_.max)
  114.          {
  115.             _loc13_.max = _loc5_;
  116.          }
  117.       }
  118.       
  119.       private function distributeItemHeight(param1:GridItem, param2:Number, param3:Number, param4:Array) : void
  120.       {
  121.          var _loc11_:int = 0;
  122.          var _loc12_:GridRowInfo = null;
  123.          var _loc13_:Number = NaN;
  124.          var _loc14_:Number = NaN;
  125.          var _loc5_:Number = param1.maxHeight;
  126.          var _loc6_:Number = param1.getExplicitOrMeasuredHeight();
  127.          var _loc7_:Number = param1.minHeight;
  128.          var _loc8_:int = param1.rowSpan;
  129.          var _loc9_:Number = 0;
  130.          var _loc10_:Boolean = false;
  131.          _loc11_ = param2;
  132.          while(_loc11_ < param2 + _loc8_)
  133.          {
  134.             _loc12_ = param4[_loc11_];
  135.             _loc6_ -= _loc12_.preferred;
  136.             _loc7_ -= _loc12_.min;
  137.             _loc9_ += _loc12_.flex;
  138.             _loc11_++;
  139.          }
  140.          if(_loc8_ > 1)
  141.          {
  142.             _loc13_ = param3 * (_loc8_ - 1);
  143.             _loc6_ -= _loc13_;
  144.             _loc7_ -= _loc13_;
  145.          }
  146.          if(_loc9_ == 0)
  147.          {
  148.             _loc9_ = _loc8_;
  149.             _loc10_ = true;
  150.          }
  151.          _loc6_ = _loc6_ > 0 ? Number(Math.ceil(_loc6_ / _loc9_)) : Number(0);
  152.          _loc7_ = _loc7_ > 0 ? Number(Math.ceil(_loc7_ / _loc9_)) : Number(0);
  153.          _loc11_ = param2;
  154.          while(_loc11_ < param2 + _loc8_)
  155.          {
  156.             _loc12_ = param4[_loc11_];
  157.             _loc14_ = !!_loc10_ ? Number(1) : Number(_loc12_.flex);
  158.             _loc12_.preferred += _loc6_ * _loc14_;
  159.             _loc12_.min += _loc7_ * _loc14_;
  160.             _loc11_++;
  161.          }
  162.          if(_loc8_ == 1 && _loc5_ < _loc12_.max)
  163.          {
  164.             _loc12_.max = _loc5_;
  165.          }
  166.       }
  167.       
  168.       override public function invalidateSize() : void
  169.       {
  170.          if(!isNaN(explicitWidth) && !isNaN(explicitHeight))
  171.          {
  172.             needToRemeasure = true;
  173.          }
  174.          super.invalidateSize();
  175.       }
  176.       
  177.       override protected function measure() : void
  178.       {
  179.          var _loc4_:GridRow = null;
  180.          var _loc5_:GridItem = null;
  181.          var _loc6_:int = 0;
  182.          var _loc7_:int = 0;
  183.          var _loc8_:int = 0;
  184.          var _loc12_:int = 0;
  185.          var _loc19_:Number = NaN;
  186.          var _loc22_:GridRow = null;
  187.          var _loc23_:EdgeMetrics = null;
  188.          var _loc25_:int = 0;
  189.          var _loc26_:int = 0;
  190.          var _loc27_:int = 0;
  191.          var _loc28_:* = undefined;
  192.          var _loc29_:* = undefined;
  193.          var _loc30_:GridRowInfo = null;
  194.          var _loc31_:GridColumnInfo = null;
  195.          var _loc32_:Number = NaN;
  196.          var _loc1_:int = 0;
  197.          var _loc2_:int = 0;
  198.          var _loc3_:Array = [];
  199.          var _loc9_:Array = [];
  200.          var _loc10_:int = 0;
  201.          while(_loc10_ < numChildren)
  202.          {
  203.             if((_loc4_ = GridRow(getChildAt(_loc10_))).includeInLayout)
  204.             {
  205.                _loc9_.push(_loc4_);
  206.                _loc1_++;
  207.             }
  208.             _loc10_++;
  209.          }
  210.          _loc6_ = 0;
  211.          while(_loc6_ < _loc1_)
  212.          {
  213.             _loc8_ = 0;
  214.             _loc4_ = _loc9_[_loc6_];
  215.             _loc4_.numGridItems = _loc4_.numChildren;
  216.             _loc4_.rowIndex = _loc6_;
  217.             _loc7_ = 0;
  218.             while(_loc7_ < _loc4_.numGridItems)
  219.             {
  220.                if(_loc6_ > 0)
  221.                {
  222.                   _loc25_ = _loc3_[_loc8_];
  223.                   while(!isNaN(_loc25_) && _loc25_ >= _loc6_)
  224.                   {
  225.                      _loc8_++;
  226.                      _loc25_ = _loc3_[_loc8_];
  227.                   }
  228.                }
  229.                (_loc5_ = GridItem(_loc4_.getChildAt(_loc7_))).colIndex = _loc8_;
  230.                if(_loc5_.rowSpan > 1)
  231.                {
  232.                   _loc26_ = _loc6_ + _loc5_.rowSpan - 1;
  233.                   _loc27_ = 0;
  234.                   while(_loc27_ < _loc5_.colSpan)
  235.                   {
  236.                      _loc3_[_loc8_ + _loc27_] = _loc26_;
  237.                      _loc27_++;
  238.                   }
  239.                }
  240.                _loc8_ += _loc5_.colSpan;
  241.                _loc7_++;
  242.             }
  243.             if(_loc8_ > _loc2_)
  244.             {
  245.                _loc2_ = _loc8_;
  246.             }
  247.             _loc6_++;
  248.          }
  249.          rowHeights = new Array(_loc1_);
  250.          columnWidths = new Array(_loc2_);
  251.          _loc6_ = 0;
  252.          while(_loc6_ < _loc1_)
  253.          {
  254.             rowHeights[_loc6_] = new GridRowInfo();
  255.             _loc6_++;
  256.          }
  257.          _loc6_ = 0;
  258.          while(_loc6_ < _loc2_)
  259.          {
  260.             columnWidths[_loc6_] = new GridColumnInfo();
  261.             _loc6_++;
  262.          }
  263.          var _loc11_:int = int.MAX_VALUE;
  264.          var _loc13_:int = 1;
  265.          var _loc14_:Number = getStyle("horizontalGap");
  266.          var _loc15_:Number = getStyle("verticalGap");
  267.          do
  268.          {
  269.             _loc12_ = _loc13_;
  270.             _loc13_ = _loc11_;
  271.             _loc6_ = 0;
  272.             while(_loc6_ < _loc1_)
  273.             {
  274.                (_loc4_ = _loc9_[_loc6_]).columnWidths = columnWidths;
  275.                _loc4_.rowHeights = rowHeights;
  276.                _loc7_ = 0;
  277.                while(_loc7_ < _loc4_.numGridItems)
  278.                {
  279.                   _loc28_ = (_loc5_ = GridItem(_loc4_.getChildAt(_loc7_))).rowSpan;
  280.                   _loc29_ = _loc5_.colSpan;
  281.                   if(_loc28_ == _loc12_)
  282.                   {
  283.                      distributeItemHeight(_loc5_,_loc6_,_loc15_,rowHeights);
  284.                   }
  285.                   else if(_loc28_ > _loc12_ && _loc28_ < _loc13_)
  286.                   {
  287.                      _loc13_ = _loc28_;
  288.                   }
  289.                   if(_loc29_ == _loc12_)
  290.                   {
  291.                      distributeItemWidth(_loc5_,_loc5_.colIndex,_loc14_,columnWidths);
  292.                   }
  293.                   else if(_loc29_ > _loc12_ && _loc29_ < _loc13_)
  294.                   {
  295.                      _loc13_ = _loc29_;
  296.                   }
  297.                   _loc7_++;
  298.                }
  299.                _loc6_++;
  300.             }
  301.          }
  302.          while(_loc13_ < _loc11_);
  303.          
  304.          var _loc16_:Number = 0;
  305.          var _loc17_:Number = 0;
  306.          var _loc18_:Number = 0;
  307.          _loc19_ = 0;
  308.          _loc6_ = 0;
  309.          while(_loc6_ < _loc1_)
  310.          {
  311.             if((_loc30_ = rowHeights[_loc6_]).min > _loc30_.preferred)
  312.             {
  313.                _loc30_.min = _loc30_.preferred;
  314.             }
  315.             if(_loc30_.max < _loc30_.preferred)
  316.             {
  317.                _loc30_.max = _loc30_.preferred;
  318.             }
  319.             _loc17_ += _loc30_.min;
  320.             _loc19_ += _loc30_.preferred;
  321.             _loc6_++;
  322.          }
  323.          _loc6_ = 0;
  324.          while(_loc6_ < _loc2_)
  325.          {
  326.             if((_loc31_ = columnWidths[_loc6_]).min > _loc31_.preferred)
  327.             {
  328.                _loc31_.min = _loc31_.preferred;
  329.             }
  330.             if(_loc31_.max < _loc31_.preferred)
  331.             {
  332.                _loc31_.max = _loc31_.preferred;
  333.             }
  334.             _loc16_ += _loc31_.min;
  335.             _loc18_ += _loc31_.preferred;
  336.             _loc6_++;
  337.          }
  338.          var _loc20_:EdgeMetrics;
  339.          var _loc21_:Number = (_loc20_ = viewMetricsAndPadding).left + _loc20_.right;
  340.          var _loc24_:Number = 0;
  341.          if(_loc2_ > 1)
  342.          {
  343.             _loc21_ += getStyle("horizontalGap") * (_loc2_ - 1);
  344.          }
  345.          _loc6_ = 0;
  346.          while(_loc6_ < _loc1_)
  347.          {
  348.             if((_loc32_ = (_loc23_ = (_loc22_ = _loc9_[_loc6_]).viewMetricsAndPadding).left + _loc23_.right) > _loc24_)
  349.             {
  350.                _loc24_ = _loc32_;
  351.             }
  352.             _loc6_++;
  353.          }
  354.          _loc21_ += _loc24_;
  355.          _loc16_ += _loc21_;
  356.          _loc18_ += _loc21_;
  357.          _loc21_ = _loc20_.top + _loc20_.bottom;
  358.          if(_loc1_ > 1)
  359.          {
  360.             _loc21_ += getStyle("verticalGap") * (_loc1_ - 1);
  361.          }
  362.          _loc6_ = 0;
  363.          while(_loc6_ < _loc1_)
  364.          {
  365.             _loc23_ = (_loc22_ = _loc9_[_loc6_]).viewMetricsAndPadding;
  366.             _loc21_ += _loc23_.top + _loc23_.bottom;
  367.             _loc6_++;
  368.          }
  369.          _loc17_ += _loc21_;
  370.          _loc19_ += _loc21_;
  371.          _loc6_ = 0;
  372.          while(_loc6_ < _loc1_)
  373.          {
  374.             (_loc22_ = _loc9_[_loc6_]).updateRowMeasurements();
  375.             _loc6_++;
  376.          }
  377.          super.measure();
  378.          measuredMinWidth = Math.max(measuredMinWidth,_loc16_);
  379.          measuredMinHeight = Math.max(measuredMinHeight,_loc17_);
  380.          measuredWidth = Math.max(measuredWidth,_loc18_);
  381.          measuredHeight = Math.max(measuredHeight,_loc19_);
  382.          needToRemeasure = false;
  383.       }
  384.    }
  385. }
  386.